{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:45.644218Z",
     "start_time": "2025-01-17T04:49:41.250260Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 数据准备",
   "id": "1073bc64c567ba13"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:47.439130Z",
     "start_time": "2025-01-17T04:49:45.645230Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)\n"
   ],
   "id": "55788f25672e1ebe",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.322653Z",
     "start_time": "2025-01-17T04:49:47.440132Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        # img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "_mean, _std = cal_mean_std(train_ds)\n",
    "print(_mean, _std)\n",
    "\n",
    "transforms = nn.Sequential(\n",
    "    Normalize(mean=_mean, std=_std)\n",
    ")"
   ],
   "id": "7296e2499aa5be79",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.2860]) tensor([0.3205])\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 定义模型",
   "id": "b5e4f17ae389c008"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.342092Z",
     "start_time": "2025-01-17T04:49:54.323660Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=10):\n",
    "        super().__init__()\n",
    "        self.transform = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()  # 展平层\n",
    "        self.linear_relu_stack = nn.Sequential(  # 线性层+激活层堆叠\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            # bn：批归一化层，对输入数据进行归一化处理，使得数据分布更加一致，加快模型收敛速度\n",
    "            # 一般而言，先batch norm 后 激活函数\n",
    "            # 1d：表示输入的维度是1\n",
    "            nn.BatchNorm1d(100), # num of features=100\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加layers_num-1个线性层+激活层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"linear{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"bn{i}\", nn.BatchNorm1d(100))\n",
    "            self.linear_relu_stack.add_module(f\"selu{i}\", nn.SELU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"linear_out\", nn.Linear(100, 10))\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        print(\"初始化权重\")\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        print(\"权重初始化完成\")\n",
    "\n",
    "    def forward(self, x):  # 前向传播\n",
    "        x = self.transform(x)  # 预处理,标准化\n",
    "        # 将输入数据 x 展平（Flatten），通常用于将多维数据转换为一维数据。\n",
    "        x = self.flatten(x)\n",
    "        # logits 是模型的原始输出，通常是未经过 Softmax 或 Sigmoid 处理的分数。\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算模型参数数量\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")  #np.prod是计算张量的元素个数\n",
    "    total += np.prod(value.shape) \n",
    "total"
   ],
   "id": "d3016623476b4fd4",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n",
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 10000\n",
      "Linear_20\tparamerters num: 100\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_22\tparamerters num: 10000\n",
      "Linear_22\tparamerters num: 100\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_24\tparamerters num: 10000\n",
      "Linear_24\tparamerters num: 100\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_26\tparamerters num: 10000\n",
      "Linear_26\tparamerters num: 100\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_28\tparamerters num: 10000\n",
      "Linear_28\tparamerters num: 100\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_30\tparamerters num: 10000\n",
      "Linear_30\tparamerters num: 100\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_32\tparamerters num: 10000\n",
      "Linear_32\tparamerters num: 100\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_34\tparamerters num: 10000\n",
      "Linear_34\tparamerters num: 100\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_36\tparamerters num: 10000\n",
      "Linear_36\tparamerters num: 100\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_38\tparamerters num: 10000\n",
      "Linear_38\tparamerters num: 100\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_40\tparamerters num: 1000\n",
      "Linear_40\tparamerters num: 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "275410"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练模型",
   "id": "8fb5dfcd77513c03"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.399755Z",
     "start_time": "2025-01-17T04:49:54.344108Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluate(model, data_loader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in data_loader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 前向传播\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 预测\n",
    "        preds = logits.argmax(axis=-1)  # 预测类别\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())  # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)  # 计算准确率\n",
    "    return np.mean(loss_list), acc  # # 返回验证集平均损失和准确率\n"
   ],
   "id": "24550945260b9755",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Save Best Model",
   "id": "6fd06a23a5bccc23"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.405838Z",
     "start_time": "2025-01-17T04:49:54.400758Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        self.save_dir = save_dir  # 保存路径\n",
    "        self.save_step = save_step  # 保存步数\n",
    "        self.save_best_only = save_best_only  # 是否只保存最好的模型\n",
    "        self.best_metric = -1  # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        # 创建保存路径\n",
    "        if not os.path.exists(self.save_dir):  # 如果不存在保存路径，则创建\n",
    "            os.makedirs(self.save_dir)\n",
    "\n",
    "    # 对象被调用时：当你将对象像函数一样调用时，Python 会自动调用 __call__ 方法。\n",
    "    # state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "    # metric 是指标，可以是验证集的准确率，也可以是其他指标\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return  # 不是保存步数，则直接返回\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None  # 必须传入metric\n",
    "            if metric >= self.best_metric:  # 如果当前指标大于最好的指标\n",
    "                # save checkpoint\n",
    "                # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"06_best.ckpt\"))\n",
    "                self.best_metric = metric  # 更新最好的指标\n",
    "        else:\n",
    "            # 保存模型\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "            # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n"
   ],
   "id": "e93aec97aec45c4e",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Early Stopping",
   "id": "3f9a004729448217"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.411722Z",
     "start_time": "2025-01-17T04:49:54.406842Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        self.patience = patience  # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta  # 最小的提升幅度\n",
    "        self.best_metric = -1  # 记录的最好的指标\n",
    "        self.counter = 0  # 计数器，记录连续多少个step没有提升\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果指标提升了\n",
    "            self.best_metric = metric  # 更新最好的指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加一\n",
    "\n",
    "    @property  # 使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        # 如果计数器大于等于patience，则返回True，停止训练\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "d8fdc303a4d27c00",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练",
   "id": "b56dab87e8ff6485"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.420685Z",
     "start_time": "2025-01-17T04:49:54.412726Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def training(model,\n",
    "             train_loader,\n",
    "             test_loader,\n",
    "             epoch,\n",
    "             loss_fct,\n",
    "             optimizer,\n",
    "             tensorboard_callback=None,\n",
    "             save_ckpt_callback=None,\n",
    "             early_stop_callback=None,\n",
    "             eval_step=500,\n",
    "             ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0  # 全局步数\n",
    "    model.train()  # 训练模式\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 前向传播\n",
    "                logits = model(datas)\n",
    "                loss = loss_fct(logits, labels)  # 训练集损失\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "\n",
    "                # 反向传播\n",
    "                optimizer.zero_grad()  # 梯度清零\n",
    "                loss.backward()  # 反向传播\n",
    "                optimizer.step()  # 优化器更新参数\n",
    "\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 评估\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 评估模式\n",
    "                    # 验证集损失和准确率\n",
    "                    val_loss, val_acc = evaluate(model, test_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    model.train()  # 训练模式\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # model.state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), val_acc)\n",
    "                        # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 early stopping\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        early_stop_callback(val_acc)\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 早停，返回记录字典 record_dict\n",
    "\n",
    "                # 更新进度条和全局步数\n",
    "                pbar.update(1)  # 更新进度条\n",
    "                global_step += 1  # 全局步数加一\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict  # 训练结束，返回记录字典 record_dict\n"
   ],
   "id": "2602ccd3cb633f69",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "d111e077fd6e015"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:49:54.430367Z",
     "start_time": "2025-01-17T04:49:54.421689Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 2. 定义优化器 采用SGD优化器\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3.save model checkpoint\n",
    "save_ckpt_callback = SaveCheckpointsCallback(save_dir=\"checkpoints\", save_step=500, save_best_only=True)\n",
    "\n",
    "# 4. early stopping\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.01)"
   ],
   "id": "8b42caff09582576",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:03:22.323927Z",
     "start_time": "2025-01-17T04:49:54.431382Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device)  # 将模型移到GPU上\n",
    "\n",
    "# 训练过程\n",
    "record_dict = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    test_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "1b4d7f1cfe612c71",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "752a53c4b63c4020a4c46bb38d64945b"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 26 / global_step 97500\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:03:22.726785Z",
     "start_time": "2025-01-17T05:03:22.324928Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_record_curves(record_dict, sample_step=1000):\n",
    "    # .set_index(\"step\") 将 step 列设置为 DataFrame 的索引\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    last_step = train_df.index[-1]  # 最后一步的步数\n",
    "\n",
    "    print(train_df)\n",
    "    print(val_df)\n",
    "\n",
    "    # 画图 \n",
    "    fig_num = len(train_df.columns)  # 画两张图,分别是损失和准确率\n",
    "\n",
    "    # plt.subplots：用于创建一个包含多个子图的图形窗口。\n",
    "    # 1：表示子图的行数为 1。\n",
    "    # fig_num：表示子图的列数，即子图的数量。\n",
    "    # figsize=(5 * fig_num, 5)：设置整个图形窗口的大小，宽度为 5 * fig_num，高度为 5。\n",
    "    # fig：返回的图形对象（Figure），用于操作整个图形窗口。\n",
    "    # axs：返回的子图对象（Axes 或 Axes 数组），用于操作每个子图。\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index 是 x 轴数据（通常是 step）。\n",
    "        # train_df[item] 是 y 轴数据（当前指标的值）。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=\"train:\" + item)\n",
    "        # val_df.index 是 x 轴数据。\n",
    "        # val_df[item] 是 y 轴数据。\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=\"val:\" + item)\n",
    "        axs[idx].grid()  # 显示网格\n",
    "        axs[idx].legend()  # 显示图例\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))  # 设置x轴刻度\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{x // 1000}k\", range(0, last_step + 1, 5000)))  # 设置x轴标签\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_record_curves(record_dict)"
   ],
   "id": "de28437c6058f608",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           loss     acc\n",
      "step                   \n",
      "0      2.766322  0.2500\n",
      "1000   0.483711  0.8125\n",
      "2000   0.396318  0.8125\n",
      "3000   0.185443  0.9375\n",
      "4000   0.411966  0.8750\n",
      "...         ...     ...\n",
      "93000  0.222803  0.9375\n",
      "94000  0.421809  0.9375\n",
      "95000  0.115924  0.9375\n",
      "96000  0.488340  0.8125\n",
      "97000  0.325249  0.8750\n",
      "\n",
      "[98 rows x 2 columns]\n",
      "           loss     acc\n",
      "step                   \n",
      "0      2.802001  0.0886\n",
      "3750   0.446289  0.8396\n",
      "7500   0.401879  0.8571\n",
      "11250  0.393498  0.8552\n",
      "15000  0.385958  0.8636\n",
      "18750  0.367674  0.8659\n",
      "22500  0.367178  0.8665\n",
      "26250  0.369821  0.8652\n",
      "30000  0.360114  0.8699\n",
      "33750  0.352163  0.8703\n",
      "37500  0.347827  0.8697\n",
      "41250  0.347857  0.8735\n",
      "45000  0.335738  0.8758\n",
      "48750  0.339299  0.8766\n",
      "52500  0.337729  0.8775\n",
      "56250  0.340032  0.8797\n",
      "60000  0.332057  0.8805\n",
      "63750  0.340455  0.8752\n",
      "67500  0.335091  0.8767\n",
      "71250  0.326786  0.8828\n",
      "75000  0.317470  0.8834\n",
      "78750  0.327174  0.8782\n",
      "82500  0.322621  0.8839\n",
      "86250  0.318410  0.8818\n",
      "90000  0.322840  0.8819\n",
      "93750  0.326986  0.8782\n",
      "97500  0.323886  0.8817\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:03:22.733661Z",
     "start_time": "2025-01-17T05:03:22.727790Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"train\"][-5:]",
   "id": "775b113bb78383fa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3311646282672882, 'acc': 0.875, 'step': 97496},\n",
       " {'loss': 0.08344437181949615, 'acc': 0.9375, 'step': 97497},\n",
       " {'loss': 0.481973797082901, 'acc': 0.875, 'step': 97498},\n",
       " {'loss': 0.5213038325309753, 'acc': 0.75, 'step': 97499},\n",
       " {'loss': 0.1823490411043167, 'acc': 0.875, 'step': 97500}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:03:22.741717Z",
     "start_time": "2025-01-17T05:03:22.735667Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"val\"][-10:]",
   "id": "dbb21c010aaef95e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3404549137681723, 'acc': 0.8752, 'step': 63750},\n",
       " {'loss': 0.33509101286530496, 'acc': 0.8767, 'step': 67500},\n",
       " {'loss': 0.3267864435046911, 'acc': 0.8828, 'step': 71250},\n",
       " {'loss': 0.3174701872110367, 'acc': 0.8834, 'step': 75000},\n",
       " {'loss': 0.3271738049417734, 'acc': 0.8782, 'step': 78750},\n",
       " {'loss': 0.3226207765370607, 'acc': 0.8839, 'step': 82500},\n",
       " {'loss': 0.31840995409190653, 'acc': 0.8818, 'step': 86250},\n",
       " {'loss': 0.32284035924971105, 'acc': 0.8819, 'step': 90000},\n",
       " {'loss': 0.3269864036411047, 'acc': 0.8782, 'step': 93750},\n",
       " {'loss': 0.3238858045935631, 'acc': 0.8817, 'step': 97500}]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 评估以及上线",
   "id": "1fa2f200745f7b63"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:03:22.754505Z",
     "start_time": "2025-01-17T05:03:22.744721Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = NeuralNetwork()  #上线时加载模型\n",
    "model = model.to(device)  # 将模型移到GPU上"
   ],
   "id": "b106406c03208c15",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:04:58.474567Z",
     "start_time": "2025-01-17T05:04:56.508998Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 加载最好的模型\n",
    "# torch.load：加载保存的模型权重或整个模型。\n",
    "# \"checkpoints/best.ckpt\"：模型权重文件路径。\n",
    "# weights_only=True：仅加载模型的权重，而不是整个模型（包括结构和参数）。这是 PyTorch 2.1 引入的新特性，用于增强安全性。\n",
    "# map_location=device：将模型加载到当前设备（GPU或CPU）。\n",
    "model.load_state_dict(torch.load(\"checkpoints/06_best.ckpt\", weights_only=True, map_location=device))  # 加载最好的模型\n",
    "\n",
    "model.eval()  # 评估模式\n",
    "loss, acc = evaluate(model, test_loader, loss_fct)\n",
    "print(f\"Test loss: {loss:.4f}, Test acc: {acc:.4f}\")"
   ],
   "id": "26cdacda63d5388e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.3226, Test acc: 0.8839\n"
     ]
    }
   ],
   "execution_count": 15
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
